package cn.feng.thinkInJava.a9_3_容器.containers.a17_05_00;

//: containers/Lists.java
// Things you can do with Lists.
import java.util.*;
import net.mindview.util.*;
import static net.mindview.util.Print.*;

/**
 * List的功能方法
 * 
 * @author fengyu
 * @date 2015年8月9日
 */
public class Lists
{
	private static boolean b;
	private static String s;
	private static int i;
	private static Iterator<String> it;
	private static ListIterator<String> lit;
	
	public static void basicTest(List<String> a)
	{
		a.add(1,"x"); // Add at location 1
		a.add("x"); // Add at end
		// Add a collection:
		a.addAll(Countries.names(25));
		// Add a collection starting at location 3:
		a.addAll(3,Countries.names(25));
		b=a.contains("1"); // Is it in there?
		// Is the entire collection in there?
		b=a.containsAll(Countries.names(25));
		// Lists allow random access, which is cheap
		// for ArrayList, expensive for LinkedList:
		s=a.get(1); // Get (typed) object at location 1
		i=a.indexOf("1"); // Tell index of object
		b=a.isEmpty(); // Any elements inside?
		it=a.iterator(); // Ordinary Iterator
		lit=a.listIterator(); // ListIterator
		lit=a.listIterator(3); // Start at loc 3
		i=a.lastIndexOf("1"); // Last match
		a.remove(1); // Remove location 1
		a.remove("3"); // Remove this object
		a.set(1,"y"); // Set location 1 to "y"
		// Keep everything that's in the argument
		// (the intersection of the two sets):
		a.retainAll(Countries.names(25));
		// Remove everything that's in the argument:
		a.removeAll(Countries.names(25));
		i=a.size(); // How big is it?
		a.clear(); // Remove all elements
	}
	
	public static void iterMotion(List<String> a)
	{
		ListIterator<String> it=a.listIterator();
		b=it.hasNext();
		b=it.hasPrevious();
		s=it.next();
		i=it.nextIndex();
		s=it.previous();
		i=it.previousIndex();
	}
	
	public static void iterManipulation(List<String> a)
	{
		ListIterator<String> it=a.listIterator();
		it.add("47");
		// Must move to an element after add():
		it.next();
		// Remove the element after the newly produced one:
		it.remove();
		// Must move to an element after remove():
		it.next();
		// Change the element after the deleted one:
		it.set("47");
	}
	
	public static void testVisual(List<String> a)
	{
		print(a);
		List<String> b=Countries.names(25);
		print("b = "+b);
		a.addAll(b);
		a.addAll(b);
		print(a);
		// Insert, remove, and replace elements
		// using a ListIterator:
		ListIterator<String> x=a.listIterator(a.size()/2);
		x.add("one");
		print(a);
		print(x.next());
		x.remove();
		print(x.next());
		x.set("47");
		print(a);
		// Traverse the list backwards:
		x=a.listIterator(a.size());
		while(x.hasPrevious())
			printnb(x.previous()+" ");
		print();
		print("testVisual finished");
	}
	
	// There are some things that only LinkedLists can do:
	public static void testLinkedList()
	{
		LinkedList<String> ll=new LinkedList<String>();
		ll.addAll(Countries.names(25));
		print(ll);
		// Treat it like a stack, pushing:
		ll.addFirst("one");
		ll.addFirst("two");
		print(ll);
		// Like "peeking" at the top of a stack:
		print(ll.getFirst());
		// Like popping a stack:
		print(ll.removeFirst());
		print(ll.removeFirst());
		// Treat it like a queue, pulling elements
		// off the tail end:
		print(ll.removeLast());
		print(ll);
	}
	
	public static void main(String[] args)
	{
		// Make and fill a new list each time:
		basicTest(new LinkedList<String>(Countries.names(25)));
		basicTest(new ArrayList<String>(Countries.names(25)));
		iterMotion(new LinkedList<String>(Countries.names(25)));
		iterMotion(new ArrayList<String>(Countries.names(25)));
		iterManipulation(new LinkedList<String>(Countries.names(25)));
		iterManipulation(new ArrayList<String>(Countries.names(25)));
		testVisual(new LinkedList<String>(Countries.names(25)));
		testLinkedList();
	}
} /* (Execute to see output) */// :~
